Artifact: Use-Case Storyboard
 Use Case Storyboard |
A use-case storyboard is a logical and conceptual description of how a use case is provided by the user interface, including the interaction required between the actor(s) and the system. |
| UML representation: | Collaboration, stereotyped as ½use-case storyboard╗. |
| Worker: | User-Interface Designer |
| Sample Reports: | Report: Use-Case-Storyboard <use-case name> |
| More information: | Guidelines: Use-Case Storyboard |
| Input to Activities: | Output from Activities: |
Purpose
The following people use the use-case storyboards:
- user-interface designers, to build a model of the user interface;
- designers of the boundary objects participating in the use-case storyboard, to understand the objects' roles in the use cases and how the objects interact. They use this information to design and implement the boundary object (i.e., to construct the user interface);
- those who design the next version of the system to understand how the system carries out the flow of events in terms of boundary objects. For example, a change may affect a limited number of use cases, in which case the designers need to see the realization of their flow of events;
- those who test to test the system's use cases;
- the manager to plan and follow up the analysis & design work.
Properties
|
Property Name |
Brief Description |
UML Representation |
| Flow of Events - Storyboard | A high-level textual description of the interaction between the user and the system during the use case. This description is augmented with usability aspects of the use case to clarify and outline the allocation of usability requirements onto boundary classes. This description can also be augmented with boundary classes for further clarification. | Tagged value, of type "formatted text". |
| Interaction Diagrams | The diagrams (sequence and collaboration diagrams) describing how the use case is realized in terms of collaborating boundary objects and actors. | Participants are owned via aggregation "behaviors". |
| Class Diagrams | The diagrams describing the boundary classes and relationships that participate in the realization of the use case. | Participants are owned via aggregation "types" and "relationships". |
| Usability Requirements | A textual description that collects all usability requirements on the use-case storyboard that need to be taken care of during user-interface prototyping and implementation. Examples are maximum execution time (e.g., how long it should take a trained user to execute a scenario), and maximum error rate (e.g. how many errors a trained user is allowed to make when executing a scenario). | Tagged value, of type "short text". |
| References to the User-Interface Prototype | To further clarify a use-case storyboard, it can refer to the parts (e.g., windows) of the user-interface prototype corresponding to its participating boundary classes. | Tagged value, of type "short text". |
| Trace Dependency | A trace dependency to the use case in the use-case model that is storyboarded. | Owned by the system via the aggregation "trace". |
Timing
Use-case storyboards are produced as soon as their corresponding use cases are prioritized to be considered from a usability perspective. Use-case storyboarding is done before the user interface is prototyped and implemented (i.e., both in the requirements workflow and in the analysis & design workflow).
Responsibility
A user-interface designer is responsible for the integrity of the use-case storyboard, and ensures that:
- the Flow of Events - Storyboard is readable and suits its purpose;
- the diagrams describing the use-case storyboard are readable and suit their purpose;
- the Usability Requirements are readable and suit their purpose, and that they correctly captures the usability requirements of the corresponding use case in the use-case model;
- the trace dependency to the corresponding use case in the use-case model is correct;
- the relationships, such as communicates-associations, include- and extend-relationships, of the corresponding use case in the use-case model are handled correctly within the use-case storyboard.
We recommend that the user-interface designer responsible for a use-case
storyboard is also responsible for the boundary classes and relationships
employed in the use-case storyboard.
